{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8f893d45",
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "import random\n",
    "\n",
    "import sys \n",
    "sys.path.append(\"..\") \n",
    "import rl_utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0ce1910d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PolicyNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return F.softmax(self.fc2(x), dim=1)\n",
    "    \n",
    "class ValueNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, 1)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return self.fc2(x)\n",
    "\n",
    "class PPO:\n",
    "    ''' PPO算法,采用截断方式 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, actor_lr, critic_lr, lmbda, epochs, eps, gamma, device):\n",
    "        self.actor = PolicyNet(state_dim, hidden_dim, action_dim).to(device)\n",
    "        self.critic = ValueNet(state_dim, hidden_dim).to(device)\n",
    "        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=actor_lr)\n",
    "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=critic_lr)\n",
    "        self.gamma = gamma\n",
    "        self.lmbda = lmbda\n",
    "        # 一条序列的数据用于训练轮数\n",
    "        self.epochs = epochs\n",
    "        # PPO中截断范围的参数\n",
    "        self.eps = eps\n",
    "        self.device = device\n",
    "    \n",
    "    def take_action(self, state):\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        probs = self.actor(state)\n",
    "        action_dist = torch.distributions.Categorical(probs)\n",
    "        action = action_dist.sample()\n",
    "        return action.item()\n",
    "\n",
    "    def update(self, transition_dict):\n",
    "        states = torch.tensor(transition_dict['states'], dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'], dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        td_target = rewards + self.gamma * self.critic(next_states) * (1 - dones)\n",
    "        td_delta = td_target - self.critic(states)\n",
    "        advantage = rl_utils.compute_advantage(self.gamma, self.lmbda, td_delta.cpu()).to(self.device)\n",
    "        old_log_probs = torch.log(self.actor(states).gather(1, actions)).detach()\n",
    "    \n",
    "        for _ in range(self.epochs):\n",
    "            log_probs = torch.log(self.actor(states).gather(1, actions))\n",
    "            ratio = torch.exp(log_probs - old_log_probs)\n",
    "            surr1 = ratio * advantage\n",
    "            surr2 = torch.clamp(ratio, 1 - self.eps, 1 + self.eps) * advantage # 截断\n",
    "            actor_loss = torch.mean(-torch.min(surr1, surr2))\n",
    "            critic_loss = torch.mean(F.mse_loss(self.critic(states), td_target.detach()))\n",
    "            self.actor_optimizer.zero_grad()\n",
    "            self.critic_optimizer.zero_grad()\n",
    "            actor_loss.backward()\n",
    "            critic_loss.backward()\n",
    "            self.actor_optimizer.step()\n",
    "            self.critic_optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "aaed3029",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0:   0%|          | 0/25 [00:00<?, ?it/s]/tmp/ipykernel_1002/3538057173.py:37: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at /pytorch/torch/csrc/utils/tensor_new.cpp:254.)\n",
      "  state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
      "Iteration 0: 100%|██████████| 25/25 [00:01<00:00, 13.38it/s, episode=20, return=42.500]\n",
      "Iteration 1: 100%|██████████| 25/25 [00:02<00:00, 11.02it/s, episode=45, return=150.200]\n",
      "Iteration 2: 100%|██████████| 25/25 [00:03<00:00,  7.56it/s, episode=70, return=335.000]\n",
      "Iteration 3: 100%|██████████| 25/25 [00:04<00:00,  5.86it/s, episode=95, return=406.200]\n",
      "Iteration 4: 100%|██████████| 25/25 [00:03<00:00,  6.36it/s, episode=120, return=412.000]\n",
      "Iteration 5: 100%|██████████| 25/25 [00:05<00:00,  4.92it/s, episode=145, return=497.200]\n",
      "Iteration 6: 100%|██████████| 25/25 [00:05<00:00,  4.88it/s, episode=170, return=500.000]\n",
      "Iteration 7: 100%|██████████| 25/25 [00:05<00:00,  4.78it/s, episode=195, return=476.000]\n",
      "Iteration 8: 100%|██████████| 25/25 [00:04<00:00,  5.10it/s, episode=220, return=486.100]\n",
      "Iteration 9: 100%|██████████| 25/25 [00:05<00:00,  4.86it/s, episode=245, return=500.000]\n"
     ]
    }
   ],
   "source": [
    "actor_lr = 1e-3\n",
    "critic_lr = 1e-2\n",
    "num_episodes = 250\n",
    "hidden_dim = 128\n",
    "gamma = 0.98\n",
    "lmbda = 0.95\n",
    "epochs = 10\n",
    "eps = 0.2\n",
    "device = 'cpu'\n",
    "\n",
    "env_name = 'CartPole-v1'\n",
    "env = gym.make(env_name)\n",
    "torch.manual_seed(0)\n",
    "state_dim = env.observation_space.shape[0]\n",
    "action_dim = env.action_space.n\n",
    "ppo_agent = PPO(state_dim, hidden_dim, action_dim, actor_lr, critic_lr, lmbda, epochs, eps, gamma, device)\n",
    "return_list = rl_utils.train_on_policy_agent(env, ppo_agent, num_episodes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f350004e",
   "metadata": {},
   "outputs": [],
   "source": [
    "rl_utils.play_game(env_name, ppo_agent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f504b081",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_expert_data(n_episode):\n",
    "    states = []\n",
    "    actions = []\n",
    "    for episode in range(n_episode):\n",
    "        state, _= env.reset()\n",
    "        done = False\n",
    "        while not done:\n",
    "            action = ppo_agent.take_action(state)\n",
    "            states.append(state)\n",
    "            actions.append(action)\n",
    "            state, reward, terminated, truncated, info = env.step(action)\n",
    "            if terminated or truncated:\n",
    "                done = True\n",
    "            # state = next_state\n",
    "    return np.array(states), np.array(actions)\n",
    "\n",
    "# env.seed(0)\n",
    "torch.manual_seed(0)\n",
    "random.seed(0)\n",
    "n_episode = 1\n",
    "expert_s, expert_a = sample_expert_data(n_episode)\n",
    "\n",
    "# 采样30个数据\n",
    "n_samples = 60\n",
    "random_index = random.sample(range(expert_s.shape[0]), n_samples)\n",
    "'''\n",
    "random.sample(population, k)\n",
    "参数说明\n",
    "    population：这是你要进行抽样的总体序列，可以是列表、元组、字符串或者其他可迭代对象。\n",
    "    k：表示你想要抽取的元素个数，并且这个数值必须满足0 ≤ k ≤ len(population)，不然会引发ValueError异常。\n",
    "主要特点\n",
    "    不重复抽样：random.sample()绝对不会返回重复的元素，所以k的值不能超过原序列的长度。\n",
    "    等概率抽取：原序列中的每个元素都有相同的概率被选中。\n",
    "    原地操作：该函数不会对原序列进行修改。\n",
    "'''\n",
    "expert_s = expert_s[random_index]\n",
    "expert_a = expert_a[random_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "56ffd270",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "进度条: 100%|██████████| 1000/1000 [05:23<00:00,  3.09it/s, return=269.420]\n"
     ]
    }
   ],
   "source": [
    "class BehaviorClone:\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, lr, device='cpu'):\n",
    "        self.policy = PolicyNet(state_dim, hidden_dim, action_dim).to(device)\n",
    "        self.optimizer = torch.optim.Adam(self.policy.parameters(), lr=lr)\n",
    "        self.device = device\n",
    "    \n",
    "    def learn(self, states, actions):\n",
    "        states = torch.tensor(states, dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(actions).view(-1, 1).to(self.device)\n",
    "        log_probs = torch.log(self.policy(states).gather(1, actions))\n",
    "        # 最大似然估计\n",
    "        bc_loss = torch.mean(-log_probs)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        bc_loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "    def take_action(self, state):\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        probs = self.policy(state)\n",
    "        action_dist = torch.distributions.Categorical(probs)\n",
    "        action = action_dist.sample()\n",
    "        return action.item()\n",
    "    \n",
    "def test_agent(agent, env, n_episode):\n",
    "    return_list = []\n",
    "    for episode in range(n_episode):\n",
    "        episode_return = 0\n",
    "        state, _ = env.reset()\n",
    "        done = False\n",
    "        while not done:\n",
    "            action = agent.take_action(state)\n",
    "            next_state, reward, terminated, truncated, info = env.step(action)\n",
    "            if terminated or truncated:\n",
    "                done = True\n",
    "            state = next_state\n",
    "            episode_return += reward\n",
    "        return_list.append(episode_return)\n",
    "    return np.mean(return_list)\n",
    "\n",
    "torch.manual_seed(0)\n",
    "np.random.seed(0)\n",
    "\n",
    "lr = 1e-3\n",
    "bc_agent = BehaviorClone(state_dim, hidden_dim, action_dim, lr)\n",
    "n_iterations = 1000\n",
    "batch_size = 64\n",
    "test_returns = []\n",
    "\n",
    "with tqdm(total=n_iterations, desc=\"进度条\") as pbar:\n",
    "    for i in range(n_iterations):\n",
    "        sample_indices = np.random.randint(low=0, high=expert_s.shape[0], size=batch_size)\n",
    "        bc_agent.learn(expert_s[sample_indices], expert_a[sample_indices])\n",
    "        current_return = test_agent(bc_agent, env, 5)\n",
    "        test_returns.append(current_return)\n",
    "        if (i + 1) % 10 == 0:\n",
    "            pbar.set_postfix({'return': '%.3f' % np.mean(test_returns[-10:])})\n",
    "        pbar.update(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5d7cfe6a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "iteration_list = list(range(len(test_returns)))\n",
    "plt.plot(iteration_list, test_returns)\n",
    "plt.xlabel('Iterations')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('BC on {}'.format(env_name))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2f1b6996",
   "metadata": {},
   "outputs": [],
   "source": [
    "rl_utils.play_game(env_name, bc_agent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "309659e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Discriminator(nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim + action_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, 1)\n",
    "    \n",
    "    def forward(self, x, a):\n",
    "        cat = torch.cat([x, a], dim=1)\n",
    "        x = F.relu(self.fc1(cat))\n",
    "        return torch.sigmoid(self.fc2(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e674c7b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "进度条:   0%|          | 0/500 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "进度条: 100%|██████████| 500/500 [01:30<00:00,  5.53it/s, return=500.000]\n"
     ]
    }
   ],
   "source": [
    "class GAIL:\n",
    "    def __init__(self, agent, state_dim, action_dim, hidden_dim, lr_d, device='cpu'):\n",
    "        self.discriminator = Discriminator(state_dim, hidden_dim, action_dim).to(device)\n",
    "        self.discriminator_optimizer = torch.optim.Adam(self.discriminator.parameters(), lr=lr_d)\n",
    "        self.agent = agent\n",
    "        self.device = device\n",
    "    \n",
    "    def learn(self, expert_s, expert_a, agent_s, agent_a, next_s, dones):\n",
    "        expert_states = torch.tensor(expert_s, dtype=torch.float).to(self.device)\n",
    "        agent_states = torch.tensor(agent_s, dtype=torch.float).to(self.device)\n",
    "        expert_actions = torch.tensor(expert_a).to(self.device)\n",
    "        agent_actions = torch.tensor(agent_a).to(self.device)\n",
    "        expert_actions = F.one_hot(expert_actions, num_classes=2).float()\n",
    "        agent_actions= F.one_hot(agent_actions, num_classes=2).float()\n",
    "\n",
    "        expert_prob = self.discriminator(expert_states, expert_actions)\n",
    "        agent_prob = self.discriminator(agent_states, agent_actions)\n",
    "        '''\n",
    "        expert_prob[:2] \n",
    "        tensor([[0.5022],\n",
    "                [0.5112]], grad_fn=<SliceBackward0>)\n",
    "        torch.zeros_like(expert_prob)[:2] \n",
    "        tensor([[0.],\n",
    "                [0.]])\n",
    "        agent_prob[:2] \n",
    "        tensor([[0.5032],\n",
    "                [0.5164]], grad_fn=<SliceBackward0>)\n",
    "        torch.ones_like(agent_prob)[:2] \n",
    "        tensor([[1.],\n",
    "                [1.]])            \n",
    "        '''\n",
    "        discriminator_loss = nn.BCELoss()(agent_prob, torch.ones_like(agent_prob)) \\\n",
    "                            + nn.BCELoss()(expert_prob, torch.zeros_like(expert_prob))\n",
    "        '''\n",
    "        判别器本质上是一个二分类器，其输出可以解释为：\n",
    "            输入来自专家 → 判别器输出趋近于 0\n",
    "            输入来自智能体 → 判别器输出趋近于 1\n",
    "        '''\n",
    "        self.discriminator_optimizer.zero_grad()\n",
    "        discriminator_loss.backward()\n",
    "        self.discriminator_optimizer.step()\n",
    "\n",
    "        rewards = -torch.log(agent_prob).detach().cpu().numpy()\n",
    "        '''\n",
    "        GAIL 的目标是让智能体学习专家行为，而无需直接访问专家的奖励函数。\n",
    "        判别器 D(s,a) 的作用是区分：\n",
    "            专家数据：(s,a) ~ π_E（标签为 0）\n",
    "            智能体数据：(s,a) ~ π_θ（标签为 1）\n",
    "            当判别器无法区分两者时，D(s,a) ≈ 0.5，此时智能体的行为被认为接近专家行为。\n",
    "        奖励函数 r(s,a) = -log(D(s,a)) 的设计基于以下逻辑：\n",
    "        当智能体行为接近专家时：\n",
    "            D(s,a) → 0（判别器将智能体数据误判为专家数据）\n",
    "            r(s,a) = -log(0) → infty（奖励趋近于正无穷）\n",
    "        当智能体行为远离专家时：\n",
    "            D(s,a) → 1（判别器正确识别智能体数据）\n",
    "            r(s,a) = -log(1) = 0（奖励为 0）\n",
    "        中间状态：\n",
    "            D(s,a) = 0.5 时，\n",
    "            r(s,a) = -log(0.5) ≈ 0.69\n",
    "        '''\n",
    "        trainsiton_dict={\n",
    "            'states': agent_s, 'actions': agent_a, 'rewards': rewards, 'next_states': next_s, 'dones': dones}\n",
    "        self.agent.update(trainsiton_dict)\n",
    "\n",
    "torch.manual_seed(0)\n",
    "lr_d = 1e-3\n",
    "agent = PPO(state_dim, hidden_dim, action_dim, actor_lr, critic_lr, lmbda, epochs, eps, gamma, device)\n",
    "gail = GAIL(agent, state_dim, action_dim, hidden_dim, lr_d)\n",
    "n_episode = 500\n",
    "return_list = []\n",
    "\n",
    "with tqdm(total=n_episode, desc=\"进度条\") as pbar:\n",
    "    for i in range(n_episode):\n",
    "        episode_return = 0\n",
    "        state, _ = env.reset()\n",
    "        done = False\n",
    "        state_list = []\n",
    "        action_list = []\n",
    "        next_state_list = []\n",
    "        done_list = []\n",
    "        while not done:\n",
    "            action = agent.take_action(state)\n",
    "            next_state, reward, terminated, truncated, info = env.step(action)\n",
    "            if terminated or truncated:\n",
    "                done = True\n",
    "            state_list.append(state)\n",
    "            action_list.append(action)\n",
    "            next_state_list.append(next_state)\n",
    "            done_list.append(done)\n",
    "            state = next_state\n",
    "            episode_return += reward\n",
    "        return_list.append(episode_return)\n",
    "        gail.learn(expert_s, expert_a, state_list, action_list, next_state_list, done_list)\n",
    "        if (i + 1) % 10 == 0:\n",
    "            pbar.set_postfix({'return': '%.3f' % np.mean(return_list[-10:])})\n",
    "        pbar.update(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a40b4d88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "iteration_list = list(range(len(return_list)))\n",
    "plt.plot(iteration_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('GAIL on {}'.format(env_name))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f8229b7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "rl_utils.play_game(env_name, agent)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
